Video streaming is an important application over the Internet. The number of available streams, servers and users is rapidly growing and is the leading consumer of bandwidth.
“Classical” Streaming
Streaming in its original form was performed by transmitting a stream from the server to a client with little feedback. Feedback was only provided if the client did not receive data within a given time. The feedback could be done by use or lack of Acknowledgement (Ack) messages if the stream was sent over the TCP protocol or by resending requests for the stream by the client. In many cases the protocol used was RTSP.
Adaptive Bit Rate with “Classical” Streaming
Since the server and the client do not have clear visibility of the medium between them, it is practically impossible for the server to know if a stream with one specific bit-rate could reach the client or whether bandwidth congestion on the way would block the client from receiving it. Therefore, servers adopted different adaptive bit rate methods. In all cases, the servers maintain a few versions of the stream, each one encoded in a different bit-rate. In the general case, if a segment of a stream with a specific bit rate did not reach the client, the server would try to retransmit the stream with a lower bit rate.
Lower bit rates can be achieved by lowering spatial resolution, number of frames per second or simply applying stronger compression to the stream. In cases where the clients received all the transmitted segments, the server could revert to higher bit rate versions of the stream and transmit those. In these cases, the device which decided which bit rates to use was the server.
HTTP Streaming
For different reasons including firewall restrictions and compatibility between different servers and clients, the market has generally reverted (or is in the process of reverting) to HTTP streaming. When performing HTTP streaming the client requests a file download over HTTP. In this case, the client may request only parts of a file or all of it. If the client desires, it may stop the downloading of the file and ask the server to download a different file. To sum this up, in the simplest sense, HTTP streaming involves a file download from the server to the client. This type of streaming is often known as Progressive Download (PD).
Adaptive Bit Rate (ABR) with HTTP Streaming
Adaptive bit rate with HTTP streaming is a relatively new technology. When it is used, the server first saves a few different versions of the video clip. The difference is usually a bitrate difference but there might also be resolution or other differences between the versions. The different versions are chopped into small segments usually known as fragments or chunks (these words are used interchangeably in this application) which have a playback duration of a few seconds. The server sends the client a manifest file. The manifest file informs the client which versions are available, the duration of the fragments and where the client can find the different fragments.
The Client then Asks the Server to Transmit Specific Fragments of the Stream
ABR HTTP streaming can also be used with live streaming. In this case, the manifest file is constantly updated and sent to the client. In some ABR cases, each bit rate chunk is stored as a single file. In other cases, each file holds the entire stream with one specific bit rate and different chunks are simply different segments of the file. Other implementations may include only one file which is segmented by bit rates and chunks.
As in classical streaming, the client and server do not have any information regarding the medium between them. Therefore, a mechanism is needed here also to determine the stream's bit rate. In this case it is the client which makes the decision. Algorithms implemented in the client decide which bit rate chunk to request from the server. The decision may be influenced by several factors such as available buffer space, processing power of the client and bandwidth considerations such as: if the previously requested chunk was not received (probably because of network congestion)—request a lower bit rate fragment next time. Occasionally the client may request a chunk with a bit rate which is higher than the last received chunk.
The Problem
Different clients often share the same resources often referred to as the Last Mile channel. For example, cellular/mobile devices may share the same cell in newer systems or the same frequency within a cell in older systems. In cable networks, clients may share the same QAM channel. The last mile channel in all networks is limited to a specific bandwidth. Often, this bandwidth may not be enough to allow all bit rates demanded by all services transmitted to the downstream devices. In order to reduce data loss some management of the bandwidth is needed. However, with streaming, management is not available. The only methods the network operator can use are to set priorities to different devices or services and to limit bandwidth for devices or services. Both solutions are not good. When setting priorities, one service or device can consume extremely large amounts of bandwidth and completely starve other clients. Limiting bit rates poses other problems such as leaving unused bandwidth on the pipe or setting the limit so low that services cannot be delivered at all or are delivered with many interruptions. The network operator can't manage the last mile channel efficiently because it is not aware of the transactions between the servers and clients. Following are two examples of these inefficiencies but there are many more. For the sake of simplicity, in the examples the assumption is that only streaming sessions occupy the last mile channel pipe.
Unused Bandwidth
Assume that all the bandwidth is utilized and each device receives chunks as requested. Now assume that one device ceases to request the service and drops off. Bandwidth which was allocated for this device is now free but other devices are not aware of this and therefore none of them request a chunk with higher bit rate. As a result the bandwidth remains free and unused until a device requests higher bit rate. This means that at least some of the devices could have received chunks at higher bit rate and therefore better quality but this didn't happen.
Bandwidth Waste
Assume that all the bandwidth is utilized and all devices receive chunks as requested. Now assume that one device attempts to receive a chunk at a higher bit rate because it doesn't know that all the bandwidth is utilized. It requests a chunk at a higher bit rate. The server attempts to transmit the requested chunk. Now there is congestion on the last mile channel and data will be discarded. The data discarded may be data that serves any one of the devices. Statistically, more than one service will be affected. This may include the device which initiated the high bit rate request. The affected devices will not receive the chunks they requested. All these devices will experience losses in the TCP layer and would therefore send resend requests. Since the data requests are performed in the HTTP layer and are made for fragments with durations of a few seconds, this situation can't be corrected by TCP or HTTP layer mechanisms for the duration of the fragments. In effect, much data will be discarded.